package main

import "fmt"

// 如果你需要初始化大量复杂的库或框架，就需要管理其依赖关系并且按正确的顺序执行。
// 此时就可以用一个外观类来统一处理这些依赖关系，以对其进行整合

type APIA interface {
	TestA() string
}

func NewAPIA() APIA {
	return &apiRunA{}
}

type apiRunA struct{}

func (*apiRunA) TestA() string {
	return "A api runing"
}

type APIB interface {
	TestB() string
}

func NewAPIB() APIB {
	return &apiRunB{}
}

type apiRunB struct{}

func (*apiRunB) TestB() string {
	return "B api runing"
}

type API interface {
	Test() string
}

func NewAPI() API {
	return &apiRun{
		a: NewAPIA(),
		b: NewAPIB(),
	}
}

type apiRun struct {
	a APIA
	b APIB
}

func (a *apiRun) Test() string {
	aRet := a.a.TestA()
	bRet := a.b.TestB()
	return fmt.Sprintf("%s\n%s", aRet, bRet)
}

func ExampleFacade() {
	expect := "A api running\nB api running"
	api := NewAPI()
	ret := api.Test()
	if ret != expect {
		fmt.Println("error")
	}
}
